package com.kmxd.ams.client.es;

import cn.easyes.core.biz.EsPageInfo;
import cn.easyes.core.conditions.select.LambdaEsQueryWrapper;
import cn.easyes.core.conditions.update.LambdaEsUpdateWrapper;
import cn.easyes.core.core.BaseEsMapper;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.kmxd.ams.infra.arrange.base.BaseBO;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import org.elasticsearch.action.search.SearchResponse;
import org.springframework.util.CollectionUtils;

public interface IServiceEs<T> {

  /** 默认批次提交数量 */
  int DEFAULT_BATCH_SIZE = 10000;

  /**
   * 插入一条记录（选择字段，策略插入）
   *
   * @param entity 实体对象
   */
  default boolean save(T entity) {
    return SqlHelper.retBool(getBaseMapper().insert(entity));
  }

  default boolean save(T entity, String indexName) {
    return SqlHelper.retBool(getBaseMapper().insert(entity, indexName));
  }

  default boolean saveBatch(Collection<T> entityList, String indexName) {
    return saveBatch(entityList, DEFAULT_BATCH_SIZE, indexName);
  }

  /**
   * 插入（批量）
   *
   * @param entityList 实体对象集合
   * @param batchSize 插入批次数量
   */
  boolean saveBatch(Collection<T> entityList, int batchSize, String indexName);

  /**
   * 根据 ID 删除
   *
   * @param id 主键ID
   */
  default boolean removeById(Serializable id, String indexName) {
    return SqlHelper.retBool(getBaseMapper().deleteById(id, indexName));
  }

  /**
   * 根据 entity 条件，删除记录
   *
   * @param queryWrapper 实体包装类 {@link LambdaEsQueryWrapper}
   */
  default boolean remove(LambdaEsQueryWrapper<T> queryWrapper) {
    return SqlHelper.retBool(getBaseMapper().delete(queryWrapper));
  }

  /**
   * 删除（根据ID 批量删除）
   *
   * @param list 主键ID或实体列表
   */
  default boolean removeByIds(Collection<? extends Serializable> list, String indexName) {
    if (CollectionUtils.isEmpty(list)) {
      return false;
    }
    return SqlHelper.retBool(getBaseMapper().deleteBatchIds(list, indexName));
  }

  /**
   * 根据 ID 选择修改
   *
   * @param entity 实体对象
   */
  default boolean updateById(T entity, String indexName) {
    return SqlHelper.retBool(getBaseMapper().updateById(entity, indexName));
  }

  /**
   * 根据 whereEntity 条件，更新记录
   *
   * @param entity 实体对象
   * @param updateWrapper 实体对象封装操作类 {@link
   *     com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
   */
  default boolean update(T entity, LambdaEsUpdateWrapper<T> updateWrapper) {
    return SqlHelper.retBool(getBaseMapper().update(entity, updateWrapper));
  }

  /**
   * 通过查询更新数据
   *
   * @param entity
   * @param queryWrapper
   * @return
   */
  boolean updateByQuery(T entity, LambdaEsQueryWrapper<T> queryWrapper, String... indexName);
  /**
   * 根据ID 批量更新
   *
   * @param entityList 实体对象集合
   * @param indexName 索引名称
   */
  boolean updateBatchById(Collection<T> entityList, String indexName);

  boolean updateBatchById(Collection<T> entityList, int batchSize, String indexName);

  /**
   * 根据 ID 查询
   *
   * @param id 主键ID
   */
  default T getById(Serializable id) {
    return getBaseMapper().selectById(id);
  }

  /**
   * 根据 ID 查询
   *
   * @param id 主键ID
   */
  default T getById(Serializable id, String indexName) {
    return getBaseMapper().selectById(id, indexName);
  }

  /**
   * 查询（根据ID 批量查询）
   *
   * @param idList 主键ID列表
   */
  default List<T> listByIds(Collection<? extends Serializable> idList) {
    return getBaseMapper().selectBatchIds(idList);
  }

  /**
   * 查询（根据ID 批量查询）
   *
   * @param idList 主键ID列表
   */
  default List<T> listByIds(Collection<? extends Serializable> idList, String indexName) {
    return getBaseMapper().selectBatchIds(idList, indexName);
  }

  /**
   * 根据 Wrapper，查询一条记录 <br>
   *
   * <p>结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
   *
   * @param queryWrapper 实体对象封装操作类
   */
  default T getOne(LambdaEsQueryWrapper<T> queryWrapper) {
    return getOne(queryWrapper);
  }

  /**
   * 根据 Wrapper 条件，查询总记录数
   *
   * @param queryWrapper 请求条件
   * @return 统计结果
   */
  default long count(LambdaEsQueryWrapper<T> queryWrapper) {
    return SqlHelper.retCount(getBaseMapper().selectCount(queryWrapper));
  }

  /**
   * 查询列表
   *
   * @param queryWrapper 查询条件
   * @return 结果
   */
  default List<T> list(LambdaEsQueryWrapper<T> queryWrapper) {
    return getBaseMapper().selectList(queryWrapper);
  }

  /**
   * 分页查询
   *
   * @param queryWrapper 查询条件
   * @param page 页数
   * @param size 数量
   * @return 结果
   */
  default EsPageInfo<T> page(LambdaEsQueryWrapper<T> queryWrapper, Integer page, Integer size) {
    return getBaseMapper().pageQuery(queryWrapper, page, size);
  }

  /**
   * 校验索引是否存在
   *
   * @param req 请求参数，取tableId参数作为indexName
   * @return 结果
   */
  boolean existsIndex(BaseBO req);

  boolean createIndex(BaseBO req, Boolean cleanOldIndex, Integer shards, Integer replicas);

  boolean createIndex(BaseBO req, Boolean cleanOldIndex);

  /**
   * 删除索引
   *
   * @param req 请求参数，取tableId参数作为indexName
   * @return
   */
  boolean removeIndex(BaseBO req);

  /**
   * 获取对应 entity 的 BaseMapper
   *
   * @return BaseMapper
   */
  BaseEsMapper<T> getBaseMapper();

  /**
   * 获取 entity 的 class
   *
   * @return {@link Class<T>}
   */
  Class<T> getEntityClass();

  /**
   * 聚合查询
   *
   * @param queryWrapper 查询条件
   * @return 结果
   */
  default SearchResponse search(LambdaEsQueryWrapper<T> queryWrapper) {
    return getBaseMapper().search(queryWrapper);
  }

  /**
   * 获取查询信息
   *
   * @param queryWrapper
   * @return
   */
  default String getSource(LambdaEsQueryWrapper<T> queryWrapper) {
    return getBaseMapper().getSource(queryWrapper);
  }

  /**
   * 校验数据是否存在
   *
   * @param ids
   * @param tableId
   * @return
   */
  List<Long> checkDataExist(Collection<Long> ids, String tableId);

  String[] checkIndexExist(String[] indexNames);

  /**
   * 删除所有es索引信息
   *
   * @return
   */
  boolean deleteAll();
}
